package controllers

import (
	"encoding/json"
	"fmt"
	"strconv"
	"supershare/backend/middleware"
	"supershare/backend/models"
	"supershare/backend/utils"
	"time"

	"github.com/beego/beego/v2/core/logs"
)

// MeituanController 美团管理控制器
type MeituanController struct {
	BaseController
}

// List 获取美团配置列表
func (c *MeituanController) List() {
	page, pageSize := c.GetPaginationParams()
	storeId, _ := c.GetInt64("store_id", 0)
	status, _ := c.GetInt("status", -1)

	// 构建过滤条件
	filters := make(map[string]interface{})
	if storeId > 0 {
		filters["store_id"] = storeId
	}
	if status != -1 {
		filters["status"] = status
	}

	// 获取配置列表
	list, total, err := models.GetMeituanList(page, pageSize, filters)
	if err != nil {
		logs.Error("获取美团配置列表失败: %v", err)
		c.Fail("获取美团配置列表失败")
		return
	}

	c.SuccessWithPagination("获取美团配置列表成功", list, total, page, pageSize)
}

// Create 创建美团配置
func (c *MeituanController) Create() {
	admin, ok := c.GetAdmin()
	if !ok {
		return
	}

	var req models.Meituan
	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &req); err != nil {
		logs.Error("解析创建美团配置请求参数失败: %v", err)
		c.Fail("无效的请求参数")
		return
	}

	// 参数验证
	if err := c.validateMeituanRequest(&req); err != nil {
		c.Fail(err.Error())
		return
	}

	// 检查门店是否存在
	store, err := models.GetStoreById(req.StoreId)
	if err != nil || store == nil {
		logs.Error("创建美团配置时门店不存在: %v", err)
		c.Fail("门店不存在")
		return
	}

	// 检查是否已有相同门店的配置
	if existing, _ := models.GetMeituanByStoreId(req.StoreId); existing != nil {
		c.Fail("该门店已配置美团信息，请勿重复添加")
		return
	}

	// 设置创建参数
	req.StoreName = store.Name
	req.Status = 1
	if req.SyncInterval <= 0 {
		req.SyncInterval = 30 // 默认30分钟
	}
	req.LastSyncTime = time.Now().Unix()

	// 保存到数据库
	id, err := models.AddMeituan(&req)
	if err != nil {
		logs.Error("保存美团配置失败: %v", err)
		c.Fail("保存美团配置失败")
		return
	}

	// 记录操作日志
	c.LogOperation(admin, "meituan:create",
		"创建美团配置, ID: "+strconv.FormatInt(id, 10)+", 门店ID: "+strconv.FormatInt(req.StoreId, 10))

	c.Success("创建美团配置成功", map[string]interface{}{"id": id})
}

// GetOne 获取单个美团配置详情
func (c *MeituanController) GetOne() {
	id, ok := c.ValidateIDParam()
	if !ok {
		return
	}

	meituan, err := models.GetMeituanById(id)
	if err != nil {
		logs.Error("获取美团配置详情失败: %v", err)
		c.Fail("获取美团配置详情失败")
		return
	}
	if meituan == nil {
		c.Fail("美团配置不存在")
		return
	}

	c.Success("获取美团配置详情成功", meituan)
}

// Update 更新美团配置
func (c *MeituanController) Update() {
	admin, ok := c.GetAdmin()
	if !ok {
		return
	}

	id, ok := c.ValidateIDParam()
	if !ok {
		return
	}

	// 获取现有配置
	meituan, err := models.GetMeituanById(id)
	if err != nil {
		logs.Error("获取美团配置失败: %v", err)
		c.Fail("获取美团配置失败")
		return
	}
	if meituan == nil {
		c.Fail("美团配置不存在")
		return
	}

	var req models.Meituan
	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &req); err != nil {
		logs.Error("解析更新美团配置请求参数失败: %v", err)
		c.Fail("无效的请求参数")
		return
	}

	// 参数验证
	if err := c.validateMeituanRequest(&req); err != nil {
		c.Fail(err.Error())
		return
	}

	// 更新配置信息
	meituan.AppKey = req.AppKey
	meituan.AppSecret = req.AppSecret
	meituan.PoiId = req.PoiId
	meituan.Status = req.Status
	meituan.SyncInterval = req.SyncInterval
	if meituan.SyncInterval <= 0 {
		meituan.SyncInterval = 30
	}

	if err := models.UpdateMeituan(meituan); err != nil {
		logs.Error("更新美团配置失败: %v", err)
		c.Fail("更新美团配置失败")
		return
	}

	c.LogOperation(admin, "meituan:update",
		"更新美团配置, ID: "+strconv.FormatInt(id, 10)+", 门店ID: "+strconv.FormatInt(meituan.StoreId, 10))

	c.Success("更新美团配置成功", nil)
}

// Delete 删除美团配置
func (c *MeituanController) Delete() {
	admin, ok := c.GetAdmin()
	if !ok {
		return
	}

	id, ok := c.ValidateIDParam()
	if !ok {
		return
	}

	// 检查配置是否存在
	meituan, err := models.GetMeituanById(id)
	if err != nil {
		logs.Error("获取美团配置失败: %v", err)
		c.Fail("获取美团配置失败")
		return
	}
	if meituan == nil {
		c.Fail("美团配置不存在")
		return
	}

	if err := models.DeleteMeituan(id); err != nil {
		logs.Error("删除美团配置失败: %v", err)
		c.Fail("删除美团配置失败")
		return
	}

	c.LogOperation(admin, "meituan:delete",
		"删除美团配置, ID: "+strconv.FormatInt(id, 10)+", 门店ID: "+strconv.FormatInt(meituan.StoreId, 10))

	c.Success("删除美团配置成功", nil)
}

// OrderList 获取美团订单列表
func (c *MeituanController) OrderList() {
	// 获取查询参数
	page, _ := c.GetInt("page", 1)
	pageSize, _ := c.GetInt("page_size", 10)
	storeId, _ := c.GetInt64("store_id", 0)
	orderStatus, _ := c.GetInt("order_status", -1)
	isProcessed, _ := c.GetInt("is_processed", -1)
	startTimeStr := c.GetString("start_time", "")
	endTimeStr := c.GetString("end_time", "")

	// 构建过滤条件
	filters := make(map[string]interface{})
	if storeId > 0 {
		filters["store_id"] = storeId
	}
	if orderStatus != -1 {
		filters["order_status"] = orderStatus
	}
	if isProcessed != -1 {
		filters["is_processed"] = isProcessed
	}

	// 处理时间范围
	if startTimeStr != "" {
		startTime, err := time.ParseInLocation("2006-01-02", startTimeStr, time.Local)
		if err == nil {
			filters["start_time"] = startTime
		}
	}
	if endTimeStr != "" {
		endTime, err := time.ParseInLocation("2006-01-02", endTimeStr, time.Local)
		if err == nil {
			// 将结束时间设置为当天的23:59:59
			endTime = endTime.Add(24*time.Hour - time.Second)
			filters["end_time"] = endTime
		}
	}

	// 获取订单列表
	list, total, err := models.GetMeituanOrderList(page, pageSize, filters)
	if err != nil {
		logs.Error("获取美团订单列表失败: %v", err)
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "获取美团订单列表失败",
			"data":    nil,
		}
		c.ServeJSON()
		return
	}

	// 封装返回数据
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "获取美团订单列表成功",
		"data": map[string]interface{}{
			"list":       list,
			"total":      total,
			"page":       page,
			"page_size":  pageSize,
			"total_page": utils.GetTotalPage(total, pageSize),
		},
	}
	c.ServeJSON()
}

// OrderDetail 获取美团订单详情
func (c *MeituanController) OrderDetail() {
	// 获取ID参数
	idStr := c.Ctx.Input.Param(":id")
	id, err := strconv.ParseInt(idStr, 10, 64)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的ID参数",
		}
		c.ServeJSON()
		return
	}

	// 获取订单详情
	order, err := models.GetMeituanOrderById(id)
	if err != nil {
		logs.Error("获取美团订单详情失败: %v", err)
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "获取美团订单详情失败",
		}
		c.ServeJSON()
		return
	}
	if order == nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "美团订单不存在",
		}
		c.ServeJSON()
		return
	}

	// 获取关联的美团配置
	meituan, err := models.GetMeituanById(order.MeituanId)
	if err != nil {
		logs.Error("获取美团配置失败: %v", err)
	}

	// 返回数据
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "获取美团订单详情成功",
		"data": map[string]interface{}{
			"order":   order,
			"meituan": meituan,
		},
	}
	c.ServeJSON()
}

// ProcessOrder 处理美团订单
func (c *MeituanController) ProcessOrder() {
	admin, _ := middleware.GetCurrentAdmin(c.Ctx)
	if admin == nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "没有权限",
		}
		c.ServeJSON()
		return
	}
	// 解析请求参数
	var req struct {
		Id     int64 `json:"id"`
		Status int   `json:"status"` // 1-确认，2-拒绝，3-完成
	}
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		logs.Error("解析处理美团订单请求参数失败: %v", err)
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的请求参数",
		}
		c.ServeJSON()
		return
	}

	// 参数验证
	if req.Id <= 0 {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "订单ID不能为空",
		}
		c.ServeJSON()
		return
	}
	if req.Status < 1 || req.Status > 3 {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的订单状态",
		}
		c.ServeJSON()
		return
	}

	// 获取订单信息
	order, err := models.GetMeituanOrderById(req.Id)
	if err != nil {
		logs.Error("获取美团订单失败: %v", err)
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "获取美团订单失败",
		}
		c.ServeJSON()
		return
	}
	if order == nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "美团订单不存在",
		}
		c.ServeJSON()
		return
	}

	// 检查订单是否已处理
	if order.IsProcessed == 1 {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "该订单已处理，不能重复操作",
		}
		c.ServeJSON()
		return
	}

	// 处理订单
	err = models.ProcessMeituanOrder(req.Id, req.Status)
	if err != nil {
		logs.Error("处理美团订单失败: %v", err)
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "处理美团订单失败",
		}
		c.ServeJSON()
		return
	}

	// TODO: 调用美团API通知订单处理结果

	// 记录操作日志
	statusMap := map[int]string{
		1: "已确认",
		2: "已拒绝",
		3: "已完成",
	}
	logEntry := &models.OperationLog{
		UserId:        admin.Id,
		Username:      admin.Username,
		Method:        c.Ctx.Request.Method,
		Path:          c.Ctx.Request.URL.Path,
		Ip:            c.Ctx.Input.IP(),
		OperationType: "meituan:order:process",
		Description:   "处理美团订单, ID: " + strconv.FormatInt(req.Id, 10) + ", 状态: " + statusMap[req.Status],
	}
	err = models.AddOperationLog(logEntry)
	if err != nil {
		logs.Error("记录操作日志失败: %v", err)
	}

	// 返回处理结果
	c.Data["json"] = map[string]interface{}{
		"success": true,
		"message": "处理美团订单成功",
	}
	c.ServeJSON()
}

// SyncTest 测试美团订单同步
func (c *MeituanController) SyncTest() {

	admin, _ := middleware.GetCurrentAdmin(c.Ctx)
	if admin == nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "没有权限",
		}
		c.ServeJSON()
		return
	}

	// 获取ID参数
	idStr := c.Ctx.Input.Param(":id")
	id, err := strconv.ParseInt(idStr, 10, 64)
	if err != nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "无效的ID参数",
		}
		c.ServeJSON()
		return
	}

	// 获取美团配置
	meituan, err := models.GetMeituanById(id)
	if err != nil {
		logs.Error("获取美团配置失败: %v", err)
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "获取美团配置失败",
		}
		c.ServeJSON()
		return
	}
	if meituan == nil {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "美团配置不存在",
		}
		c.ServeJSON()
		return
	}

	// 检查配置状态
	if meituan.Status != 1 {
		c.Data["json"] = map[string]interface{}{
			"success": false,
			"message": "美团配置已禁用，无法同步",
		}
		c.ServeJSON()
		return
	}

	// TODO: 实现调用美团API同步订单的逻辑
	// 这里仅做示例，实际需要根据美团开放平台API文档实现

	// 模拟同步成功
	meituan.LastSyncTime = time.Now().Unix()
	err = models.UpdateMeituan(meituan)
	if err != nil {
		logs.Error("更新最后同步时间失败: %v", err)
	}

	// 记录操作日志
	logEntry := &models.OperationLog{
		UserId:        admin.Id,
		Username:      admin.Username,
		Method:        c.Ctx.Request.Method,
		Path:          c.Ctx.Request.URL.Path,
		Ip:            c.Ctx.Input.IP(),
		OperationType: "meituan:sync:test",
		Description:   "测试美团订单同步, ID: " + idStr + ", 门店ID: " + strconv.FormatInt(meituan.StoreId, 10),
	}
	err = models.AddOperationLog(logEntry)
	if err != nil {
		logs.Error("记录操作日志失败: %v", err)
	}

	c.Success("测试同步成功", nil)
}

// validateMeituanRequest 验证美团配置请求参数
func (c *MeituanController) validateMeituanRequest(req *models.Meituan) error {
	if req.StoreId <= 0 {
		return fmt.Errorf("门店ID不能为空")
	}
	if req.AppKey == "" {
		return fmt.Errorf("AppKey不能为空")
	}
	if req.AppSecret == "" {
		return fmt.Errorf("AppSecret不能为空")
	}
	if req.PoiId == "" {
		return fmt.Errorf("美团门店ID不能为空")
	}
	return nil
}
